ജാവാസ്ക്രിപ്റ്റ് പൈപ്പ്ലൈൻ ഓപ്പറേറ്റർ: ഫംഗ്ഷൻ ശൃംഖലയുടെ ഒപ്റ്റിമൈസേഷനെക്കുറിച്ചൊരു ആഴത്തിലുള്ള പഠനം

വെബ് ഡെവലപ്‌മെൻ്റിൻ്റെ എപ്പോഴും വികസിച്ചുകൊണ്ടിരിക്കുന്ന ലോകത്ത്, ഡെവലപ്പർമാരുടെ കാര്യക്ഷമതയും കോഡിൻ്റെ വ്യക്തതയും വർദ്ധിപ്പിക്കുന്ന പുതിയ ഫീച്ചറുകൾ ജാവാസ്ക്രിപ്റ്റ് സ്വീകരിക്കുന്നത് തുടരുകയാണ്. ഏറ്റവും പ്രതീക്ഷയോടെ കാത്തിരിക്കുന്ന കൂട്ടിച്ചേർക്കലുകളിലൊന്നാണ് പൈപ്പ്ലൈൻ ഓപ്പറേറ്റർ (|>). ഇപ്പോഴും ഒരു നിർദ്ദേശം മാത്രമാണെങ്കിലും, ആഴത്തിൽ കെട്ടുപിണഞ്ഞതും വായിക്കാൻ പ്രയാസമുള്ളതുമായ കോഡിനെ ലളിതവും വ്യക്തവുമായ ഡാറ്റാ പൈപ്പ്ലൈനുകളാക്കി മാറ്റി, ഫംഗ്ഷൻ കോമ്പോസിഷനെ സമീപിക്കുന്ന രീതിയിൽ ഇത് വിപ്ലവം സൃഷ്ടിക്കുമെന്ന് വാഗ്ദാനം ചെയ്യുന്നു.

ഈ സമഗ്രമായ ഗൈഡ് ജാവാസ്ക്രിപ്റ്റ് പൈപ്പ്ലൈൻ ഓപ്പറേറ്ററിനെ അതിൻ്റെ അടിസ്ഥാന ആശയങ്ങൾ മുതൽ പ്രായോഗിക ഉപയോഗങ്ങൾ വരെ പരിശോധിക്കും. ഇത് പരിഹരിക്കുന്ന പ്രശ്നങ്ങൾ, വ്യത്യസ്ത നിർദ്ദേശങ്ങൾ, യഥാർത്ഥ ലോക ഉദാഹരണങ്ങൾ, ഇതെങ്ങനെ ഇന്നുതന്നെ ഉപയോഗിച്ച് തുടങ്ങാം എന്നിവയെക്കുറിച്ചെല്ലാം നമ്മൾ ചർച്ച ചെയ്യും. ലോകമെമ്പാടുമുള്ള ഡെവലപ്പർമാർക്ക്, ഈ ഓപ്പറേറ്റർ മനസ്സിലാക്കുന്നത് കൂടുതൽ പരിപാലിക്കാൻ എളുപ്പമുള്ളതും, പ്രഖ്യാപനാത്മകവും, വ്യക്തവുമായ കോഡ് എഴുതുന്നതിനുള്ള താക്കോലാണ്.

പഴയ വെല്ലുവിളി: ഫംഗ്ഷൻ കോളുകളിലെ "പിരമിഡ് ഓഫ് ഡൂം"

ഫംഗ്ഷണൽ പ്രോഗ്രാമിംഗിൻ്റെ ഒരു അടിസ്ഥാന ശിലയും ജാവാസ്ക്രിപ്റ്റിലെ ശക്തമായ ഒരു പാറ്റേണുമാണ് ഫംഗ്ഷൻ കോമ്പോസിഷൻ. ലളിതമായ, ശുദ്ധമായ ഫംഗ്ഷനുകൾ സംയോജിപ്പിച്ച് കൂടുതൽ സങ്കീർണ്ണമായ പ്രവർത്തനങ്ങൾ നിർമ്മിക്കുന്നത് ഇതിൽ ഉൾപ്പെടുന്നു. എന്നിരുന്നാലും, ജാവാസ്ക്രിപ്റ്റിൽ കോമ്പോസിഷനുള്ള സാധാരണ സിൻടാക്സ് പെട്ടെന്ന് സങ്കീർണ്ണമാകും.

ഒരു ലളിതമായ ഡാറ്റാ പ്രോസസ്സിംഗ് ടാസ്ക് പരിഗണിക്കുക: നിങ്ങളുടെ പക്കൽ ഒരു സ്ട്രിംഗ് ഉണ്ട്, അത് ട്രിം ചെയ്യണം, വലിയക്ഷരത്തിലേക്ക് മാറ്റണം, തുടർന്ന് ഒരു ആശ്ചര്യചിഹ്നം ചേർക്കണം. നമ്മുടെ സഹായ ഫംഗ്ഷനുകൾ നിർവചിക്കാം:

            const trim = str => str.trim();
const toUpperCase = str => str.toUpperCase();
const exclaim = str => `${str}!`;
            

              
                Copy
              
            
          

ഈ മാറ്റങ്ങൾ ഒരു ഇൻപുട്ട് സ്ട്രിംഗിൽ പ്രയോഗിക്കുന്നതിന്, നിങ്ങൾ സാധാരണയായി ഫംഗ്ഷൻ കോളുകൾ ഒന്നിനുള്ളിൽ ഒന്നായി നൽകും:

            const input = "   hello world   ";
const result = exclaim(toUpperCase(trim(input)));

console.log(result); // "HELLO WORLD!"
            

              
                Copy
              
            
          

ഇത് പ്രവർത്തിക്കുമെങ്കിലും, ഇതിന് കാര്യമായ ഒരു വായനാക്ഷമത പ്രശ്നമുണ്ട്. പ്രവർത്തനങ്ങളുടെ ക്രമം മനസ്സിലാക്കാൻ, നിങ്ങൾ കോഡ് ഉള്ളിൽ നിന്ന് പുറത്തേക്ക് വായിക്കണം: ആദ്യം `trim`, പിന്നെ `toUpperCase`, ഒടുവിൽ `exclaim`. ഇത് നമ്മൾ സാധാരണയായി ടെക്സ്റ്റ് വായിക്കുന്ന രീതിക്ക് വിപരീതമാണ് (ഇടത്തുനിന്ന് വലത്തോട്ടോ വലത്തുനിന്ന് ഇടത്തോട്ടോ, എന്നാൽ ഒരിക്കലും ഉള്ളിൽ നിന്ന് പുറത്തേക്കല്ല). നിങ്ങൾ കൂടുതൽ ഫംഗ്ഷനുകൾ ചേർക്കുമ്പോൾ, ഈ നെസ്റ്റിംഗ് "പിരമിഡ് ഓഫ് ഡൂം" എന്ന് വിളിക്കപ്പെടുന്ന, ഡീബഗ് ചെയ്യാനും പരിപാലിക്കാനും ബുദ്ധിമുട്ടുള്ള കോഡ് സൃഷ്ടിക്കുന്നു.

ലോഡാഷ്, റാംഡ തുടങ്ങിയ ലൈബ്രറികൾ ഈ പ്രശ്നം പരിഹരിക്കുന്നതിനായി `flow` അല്ലെങ്കിൽ `pipe` പോലുള്ള യൂട്ടിലിറ്റി ഫംഗ്ഷനുകൾ വളരെക്കാലമായി നൽകുന്നുണ്ട്:

            import { pipe } from 'lodash/fp';

const processString = pipe(
  trim,
  toUpperCase,
  exclaim
);

const result = processString(input);
console.log(result); // "HELLO WORLD!"
            

              
                Copy
              
            
          

ഇതൊരു വലിയ മെച്ചപ്പെടുത്തലാണ്. പ്രവർത്തനങ്ങളുടെ ക്രമം ഇപ്പോൾ വ്യക്തവും രേഖീയവുമാണ്. എന്നിരുന്നാലും, ഇതിന് ഒരു ബാഹ്യ ലൈബ്രറി ആവശ്യമാണ്, ഇത് സിൻടാക്സ് സൗകര്യത്തിനായി മാത്രം നിങ്ങളുടെ പ്രോജക്റ്റിൽ മറ്റൊരു ഡിപെൻഡൻസി ചേർക്കുന്നു. പൈപ്പ്ലൈൻ ഓപ്പറേറ്റർ ഈ എർഗണോമിക് നേട്ടം ജാവാസ്ക്രിപ്റ്റ് ഭാഷയിലേക്ക് നേരിട്ട് കൊണ്ടുവരാൻ ലക്ഷ്യമിടുന്നു.

പൈപ്പ്ലൈൻ ഓപ്പറേറ്റർ (|>) പരിചയപ്പെടുത്തുന്നു: കോമ്പോസിഷന് ഒരു പുതിയ മാതൃക

പൈപ്പ്ലൈൻ ഓപ്പറേറ്റർ, ഫംഗ്ഷനുകളെ വായിക്കാൻ എളുപ്പമുള്ള, ഇടത്തുനിന്ന് വലത്തോട്ടുള്ള ക്രമത്തിൽ ബന്ധിപ്പിക്കുന്നതിന് ഒരു പുതിയ സിൻടാക്സ് നൽകുന്നു. ഇതിൻ്റെ പ്രധാന ആശയം ലളിതമാണ്: ഓപ്പറേറ്ററിൻ്റെ ഇടതുവശത്തുള്ള എക്സ്പ്രഷൻ്റെ ഫലം വലതുവശത്തുള്ള ഫംഗ്ഷനിലേക്ക് ഒരു ആർഗ്യുമെൻ്റായി കൈമാറുന്നു.

നമ്മുടെ സ്ട്രിംഗ് പ്രോസസ്സിംഗ് ഉദാഹരണം പൈപ്പ്ലൈൻ ഓപ്പറേറ്റർ ഉപയോഗിച്ച് വീണ്ടും എഴുതാം:

            const input = "   hello world   ";

const result = input
  |> trim
  |> toUpperCase
  |> exclaim;

console.log(result); // "HELLO WORLD!"
            

              
                Copy
              
            
          

വ്യത്യാസം വളരെ വലുതാണ്. കോഡ് ഇപ്പോൾ ഒരു കൂട്ടം നിർദ്ദേശങ്ങൾ പോലെ വായിക്കാം: "ഇൻപുട്ട് എടുക്കുക, അതിനെ ട്രിം ചെയ്യുക, പിന്നെ വലിയക്ഷരത്തിലേക്ക് മാറ്റുക, പിന്നെ എക്സ്ക്ലെയിം ചെയ്യുക." ഈ രേഖീയമായ ഒഴുക്ക് അവബോധജന്യവും, ഡീബഗ് ചെയ്യാൻ എളുപ്പമുള്ളതും (പരിശോധിക്കുന്നതിനായി ഒരു വരി കമൻ്റ് ചെയ്താൽ മതി), സ്വയം വിശദീകരിക്കുന്നതുമാണ്.

ഒരു പ്രധാന കുറിപ്പ്: ജാവാസ്ക്രിപ്റ്റിനെ സ്റ്റാൻഡേർഡ് ചെയ്യുന്ന കമ്മിറ്റിയായ TC39 പ്രോസസ്സിൽ പൈപ്പ്ലൈൻ ഓപ്പറേറ്റർ നിലവിൽ ഒരു സ്റ്റേജ് 2 പ്രൊപ്പോസൽ ആണ്. ഇതിനർത്ഥം ഇത് ഒരു ഡ്രാഫ്റ്റാണ്, മാറ്റങ്ങൾക്ക് വിധേയവുമാണ്. ഇത് ഇതുവരെ ഔദ്യോഗിക എക്മാസ്ക്രിപ്റ്റ് സ്റ്റാൻഡേർഡിൻ്റെ ഭാഗമായിട്ടില്ല, കൂടാതെ ബേബൽ പോലുള്ള ഒരു ട്രാൻസ്പൈലർ ഇല്ലാതെ ബ്രൗസറുകളിലോ Node.js-ലോ പിന്തുണയ്ക്കുന്നില്ല.

വ്യത്യസ്ത പൈപ്പ്ലൈൻ പ്രൊപ്പോസലുകൾ മനസ്സിലാക്കാം

പൈപ്പ്ലൈൻ ഓപ്പറേറ്ററിൻ്റെ യാത്ര സങ്കീർണ്ണമാണ്, ഇത് രണ്ട് പ്രധാന മത്സരിക്കുന്ന നിർദ്ദേശങ്ങൾ തമ്മിലുള്ള ഒരു ചർച്ചയിലേക്ക് നയിച്ചു. അന്തിമ പതിപ്പിൽ രണ്ടിൽ നിന്നും ഘടകങ്ങൾ ഉൾക്കൊള്ളാൻ സാധ്യതയുള്ളതിനാൽ, രണ്ടും മനസ്സിലാക്കേണ്ടത് അത്യാവശ്യമാണ്.

1. എഫ്# സ്റ്റൈൽ (മിനിമൽ) പ്രൊപ്പോസൽ

ഇതാണ് ഏറ്റവും ലളിതമായ പതിപ്പ്, എഫ്# ഭാഷയിൽ നിന്ന് പ്രചോദനം ഉൾക്കൊണ്ടതാണ്. ഇതിൻ്റെ സിൻടാക്സ് വൃത്തിയുള്ളതും നേരിട്ടുള്ളതുമാണ്.

സിൻടാക്സ്: expression |> function

ഈ മാതൃകയിൽ, ഇടതുവശത്തുള്ള (LHS) മൂല്യം വലതുവശത്തുള്ള (RHS) ഫംഗ്ഷനിലേക്ക് ആദ്യത്തേതും ഒരേയൊരുതുമായ ആർഗ്യുമെൻ്റായി കൈമാറുന്നു. ഇത് `function(expression)` എന്നതിന് തുല്യമാണ്.

നമ്മുടെ മുൻ ഉദാഹരണം ഈ പ്രൊപ്പോസലിൽ പൂർണ്ണമായി പ്രവർത്തിക്കുന്നു, കാരണം ഓരോ ഫംഗ്ഷനും (`trim`, `toUpperCase`, `exclaim`) ഒരൊറ്റ ആർഗ്യുമെൻ്റ് സ്വീകരിക്കുന്നു.

വെല്ലുവിളി: ഒന്നിലധികം ആർഗ്യുമെൻ്റുകളുള്ള ഫംഗ്ഷനുകൾ

ഒന്നിലധികം ആർഗ്യുമെൻ്റുകൾ ആവശ്യമുള്ള ഫംഗ്ഷനുകളിൽ മിനിമൽ പ്രൊപ്പോസലിൻ്റെ പരിമിതി വ്യക്തമാകും. ഉദാഹരണത്തിന്, ഒരു സംഖ്യയിലേക്ക് ഒരു മൂല്യം കൂട്ടിച്ചേർക്കുന്ന ഒരു ഫംഗ്ഷൻ പരിഗണിക്കുക:

            const add = (x, y) => x + y;
            

              
                Copy
              
            
          

10 എന്ന പ്രാരംഭ മൂല്യത്തിലേക്ക് 5 ചേർക്കാൻ ഇത് ഒരു പൈപ്പ്ലൈനിൽ എങ്ങനെ ഉപയോഗിക്കും? താഴെ പറയുന്ന രീതി പ്രവർത്തിക്കില്ല:

            // This does NOT work with the Minimal proposal
const result = 10 |> add(5);
            

              
                Copy
              
            
          

മിനിമൽ പ്രൊപ്പോസൽ ഇതിനെ `add(5)(10)` എന്ന് വ്യാഖ്യാനിക്കും, ഇത് `add` ഒരു കറിഡ് ഫംഗ്ഷൻ ആണെങ്കിൽ മാത്രമേ പ്രവർത്തിക്കൂ. ഇത് കൈകാര്യം ചെയ്യാൻ, നിങ്ങൾ ഒരു ആരോ ഫംഗ്ഷൻ ഉപയോഗിക്കണം:

            const result = 10 |> (x => add(x, 5)); // Works!
console.log(result); // 15
            

              
                Copy
              
            
          

• ഗുണങ്ങൾ: വളരെ ലളിതവും പ്രവചിക്കാവുന്നതും, യൂണറി (ഒറ്റ ആർഗ്യുമെൻ്റ്) ഫംഗ്ഷനുകളുടെ ഉപയോഗത്തെ പ്രോത്സാഹിപ്പിക്കുന്നു, ഇത് ഫംഗ്ഷണൽ പ്രോഗ്രാമിംഗിലെ ഒരു സാധാരണ പാറ്റേണാണ്.
• ദോഷങ്ങൾ: സ്വാഭാവികമായും ഒന്നിലധികം ആർഗ്യുമെൻ്റുകൾ എടുക്കുന്ന ഫംഗ്ഷനുകളുമായി ഇടപെടുമ്പോൾ കൂടുതൽ കോഡ് എഴുതേണ്ടി വരും, ആരോ ഫംഗ്ഷൻ്റെ അധിക ബോയിലർപ്ലേറ്റ് ആവശ്യമായി വരുന്നു.

2. സ്മാർട്ട് മിക്സ് (ഹാക്ക്) പ്രൊപ്പോസൽ

"ഹാക്ക്" പ്രൊപ്പോസൽ (ഹാക്ക് ഭാഷയുടെ പേരിൽ അറിയപ്പെടുന്നു) ഒന്നിലധികം ആർഗ്യുമെൻ്റുകളുള്ള ഫംഗ്ഷനുകളുമായി പ്രവർത്തിക്കുന്നത് കൂടുതൽ എളുപ്പമാക്കുന്നതിന് ഒരു പ്രത്യേക പ്ലെയ്‌സ്‌ഹോൾഡർ ടോക്കൺ (സാധാരണയായി #, എന്നാൽ ചർച്ചകളിൽ ? അല്ലെങ്കിൽ @ ആയും കാണപ്പെടുന്നു) അവതരിപ്പിക്കുന്നു.

സിൻടാക്സ്: expression |> function(..., #, ...)

ഈ മാതൃകയിൽ, LHS-ലെ മൂല്യം RHS ഫംഗ്ഷൻ കോളിലെ # പ്ലെയ്‌സ്‌ഹോൾഡറിൻ്റെ സ്ഥാനത്തേക്ക് പൈപ്പ് ചെയ്യപ്പെടുന്നു. പ്ലെയ്‌സ്‌ഹോൾഡർ ഉപയോഗിക്കുന്നില്ലെങ്കിൽ, അത് മിനിമൽ പ്രൊപ്പോസൽ പോലെ പ്രവർത്തിക്കുകയും മൂല്യം ആദ്യത്തെ ആർഗ്യുമെൻ്റായി കൈമാറുകയും ചെയ്യുന്നു.

നമ്മുടെ `add` ഫംഗ്ഷൻ്റെ ഉദാഹരണത്തിലേക്ക് മടങ്ങിവരാം:

            const add = (x, y) => x + y;

// Using the Hack proposal placeholder
const result = 10 |> add(#, 5);
console.log(result); // 15
            

              
                Copy
              
            
          

ഇത് ആരോ ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നതിനേക്കാൾ വളരെ വൃത്തിയുള്ളതും നേരിട്ടുള്ളതുമാണ്. പ്ലെയ്‌സ്‌ഹോൾഡർ പൈപ്പ് ചെയ്ത മൂല്യം എവിടെയാണ് ഉപയോഗിക്കുന്നതെന്ന് വ്യക്തമായി കാണിക്കുന്നു. ഡാറ്റ ആദ്യത്തെ ആർഗ്യുമെൻ്റ് അല്ലാത്ത ഫംഗ്ഷനുകൾക്ക് ഇത് പ്രത്യേകിച്ചും ശക്തമാണ്.

            const divideBy = (divisor, dividend) => dividend / divisor;

const result = 100 |> divideBy(5, #); // Equivalent to divideBy(5, 100)
console.log(result); // 20
            

              
                Copy
              
            
          

• ഗുണങ്ങൾ: വളരെ ഫ്ലെക്സിബിൾ, ഒന്നിലധികം ആർഗ്യുമെൻ്റ് ഫംഗ്ഷനുകൾക്കായി ഒരു എർഗണോമിക് സിൻടാക്സ് നൽകുന്നു, കൂടാതെ മിക്ക കേസുകളിലും ആരോ ഫംഗ്ഷൻ റാപ്പറുകളുടെ ആവശ്യം ഇല്ലാതാക്കുന്നു.
• ദോഷങ്ങൾ: തുടക്കക്കാർക്ക് അത്ര വ്യക്തമല്ലാത്ത ഒരു "മാന്ത്രിക" അക്ഷരം അവതരിപ്പിക്കുന്നു. പ്ലെയ്‌സ്‌ഹോൾഡർ ടോക്കണിൻ്റെ തിരഞ്ഞെടുപ്പ് തന്നെ വിപുലമായ ചർച്ചകൾക്ക് കാരണമായിട്ടുണ്ട്.

പ്രൊപ്പോസൽ നിലയും കമ്മ്യൂണിറ്റി ചർച്ചയും

ഈ രണ്ട് പ്രൊപ്പോസലുകൾ തമ്മിലുള്ള ചർച്ചയാണ് പൈപ്പ്ലൈൻ ഓപ്പറേറ്റർ കുറച്ചുകാലമായി സ്റ്റേജ് 2-ൽ തുടരുന്നതിനുള്ള പ്രധാന കാരണം. മിനിമൽ പ്രൊപ്പോസൽ ലാളിത്യത്തെയും ഫംഗ്ഷണൽ ശുദ്ധിയെയും പിന്തുണയ്ക്കുന്നു, അതേസമയം ഹാക്ക് പ്രൊപ്പോസൽ പ്രായോഗികതയ്ക്കും വിപുലമായ ജാവാസ്ക്രിപ്റ്റ് ഇക്കോസിസ്റ്റത്തിലെ എർഗണോമിക്സിനും മുൻഗണന നൽകുന്നു, അവിടെ ഒന്നിലധികം ആർഗ്യുമെൻ്റ് ഫംഗ്ഷനുകൾ സാധാരണമാണ്. ഇപ്പോൾ, കമ്മിറ്റി ഹാക്ക് പ്രൊപ്പോസലിലേക്ക് ചായുന്നു, പക്ഷേ അന്തിമ സ്പെസിഫിക്കേഷൻ ഇപ്പോഴും മെച്ചപ്പെടുത്തിക്കൊണ്ടിരിക്കുകയാണ്. ഏറ്റവും പുതിയ അപ്‌ഡേറ്റുകൾക്കായി ഔദ്യോഗിക TC39 പ്രൊപ്പോസൽ റിപ്പോസിറ്ററി പരിശോധിക്കേണ്ടത് അത്യാവശ്യമാണ്.

പ്രായോഗിക ഉപയോഗങ്ങളും കോഡ് ഒപ്റ്റിമൈസേഷനും

യഥാർത്ഥ ലോക ഡാറ്റാ ട്രാൻസ്ഫോർമേഷൻ സാഹചര്യങ്ങളിൽ പൈപ്പ്ലൈൻ ഓപ്പറേറ്ററിൻ്റെ യഥാർത്ഥ ശക്തി പ്രകടമാകുന്നു. ഇത് നൽകുന്ന "ഒപ്റ്റിമൈസേഷൻ" റൺടൈം പ്രകടനത്തെക്കുറിച്ചല്ല, മറിച്ച് ഡെവലപ്പർ പ്രകടനത്തെക്കുറിച്ചാണ്—കോഡിൻ്റെ വായനാക്ഷമത മെച്ചപ്പെടുത്തുക, കോഗ്നിറ്റീവ് ലോഡ് കുറയ്ക്കുക, പരിപാലനം എളുപ്പമാക്കുക.

ഉദാഹരണം 1: ഒരു സങ്കീർണ്ണ ഡാറ്റാ ട്രാൻസ്ഫോർമേഷൻ പൈപ്പ്ലൈൻ

ഒരു എപിഐയിൽ നിന്ന് നിങ്ങൾക്ക് ഉപയോക്താക്കളുടെ ഒരു ലിസ്റ്റ് ലഭിക്കുന്നുവെന്നും ഒരു റിപ്പോർട്ട് തയ്യാറാക്കാൻ അത് പ്രോസസ്സ് ചെയ്യണമെന്നും സങ്കൽപ്പിക്കുക.

            // Helper functions
const filterByCountry = (users, country) => users.filter(u => u.country === country);
const sortByRegistrationDate = users => [...users].sort((a, b) => new Date(a.registered) - new Date(b.registered));
const getFullNameAndEmail = users => users.map(u => `${u.name.first} ${u.name.last} <${u.email}>`);
const joinWithNewline = lines => lines.join('\n');

const users = [
  { name: { first: 'John', last: 'Doe' }, email: 'john.doe@example.com', country: 'USA', registered: '2022-01-15' },
  { name: { first: 'Jane', last: 'Smith' }, email: 'jane.smith@example.com', country: 'Canada', registered: '2021-11-20' },
  { name: { first: 'Carlos', last: 'Gomez' }, email: 'carlos.gomez@example.com', country: 'USA', registered: '2023-03-10' }
];

// Traditional nested approach (hard to read)
const reportNested = joinWithNewline(getFullNameAndEmail(sortByRegistrationDate(filterByCountry(users, 'USA'))));

// Pipeline operator approach (clear and linear)
const reportPiped = users
  |> (u => filterByCountry(u, 'USA')) // Minimal proposal style
  |> sortByRegistrationDate
  |> getFullNameAndEmail
  |> joinWithNewline;

// Or with the Hack proposal (even cleaner)
const reportPipedHack = users
  |> filterByCountry(#, 'USA')
  |> sortByRegistrationDate
  |> getFullNameAndEmail
  |> joinWithNewline;

console.log(reportPipedHack);
/*
John Doe 
Carlos Gomez 
*/
            

              
                Copy
              
            
          

ഈ ഉദാഹരണത്തിൽ, പൈപ്പ്ലൈൻ ഓപ്പറേറ്റർ ഒന്നിലധികം ഘട്ടങ്ങളുള്ള, ഇംപറേറ്റീവ് പ്രോസസ്സിനെ ഒരു ഡിക്ലറേറ്റീവ് ഡാറ്റാ ഫ്ലോ ആക്കി മാറ്റുന്നു. ഇത് ലോജിക് മനസ്സിലാക്കാനും, മാറ്റം വരുത്താനും, ടെസ്റ്റ് ചെയ്യാനും എളുപ്പമാക്കുന്നു.

ഉദാഹരണം 2: അസിൻക്രണസ് ഓപ്പറേഷനുകൾ ബന്ധിപ്പിക്കുന്നു

പൈപ്പ്ലൈൻ ഓപ്പറേറ്റർ `async/await`-നൊപ്പം മനോഹരമായി പ്രവർത്തിക്കുന്നു, നീണ്ട `.then()` ശൃംഖലകൾക്ക് മികച്ച ഒരു ബദൽ വാഗ്ദാനം ചെയ്യുന്നു.

            // Async helper functions
const fetchJson = async url => {
  const response = await fetch(url);
  if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
  return response.json();
};

const getFirstPostId = data => data.posts[0].id;
const fetchPostDetails = async postId => fetchJson(`https://api.example.com/posts/${postId}`);

async function getFirstPostAuthor() {
  try {
    const author = await 'https://api.example.com/data'
      |> fetchJson
      |> await # // The await can be used directly in the pipeline!
      |> getFirstPostId
      |> fetchPostDetails
      |> await #
      |> (post => post.author);

    console.log(`First post by: ${author}`);
  } catch (error) {
    console.error('Failed to fetch author:', error);
  }
}

            

              
                Copy
              
            
          

പൈപ്പ്ലൈനിനുള്ളിൽ `await` അനുവദിക്കുന്ന ഈ സിൻടാക്സ്, അസിൻക്രണസ് വർക്ക്ഫ്ലോകൾക്കായി അവിശ്വസനീയമാംവിധം വായിക്കാൻ എളുപ്പമുള്ള ഒരു ക്രമം സൃഷ്ടിക്കുന്നു. ഇത് കോഡിനെ ലളിതമാക്കുകയും നെസ്റ്റഡ് പ്രോമിസുകളുടെ വലത്തോട്ട് നീങ്ങുന്ന ഘടനയോ ഒന്നിലധികം `.then()` ബ്ലോക്കുകളുടെ കാഴ്ചയിലെ അലങ്കോലമോ ഒഴിവാക്കുന്നു.

പ്രകടനപരമായ പരിഗണനകൾ: ഇത് വെറും സിൻ്റാക്റ്റിക് ഷുഗർ ആണോ?

ഒരു കാര്യം വ്യക്തമാക്കേണ്ടതുണ്ട്: പൈപ്പ്ലൈൻ ഓപ്പറേറ്റർ ഒരു സിൻ്റാക്റ്റിക് ഷുഗർ ആണ്. നിലവിലുള്ള ജാവാസ്ക്രിപ്റ്റ് സിൻടാക്സ് ഉപയോഗിച്ച് ഇതിനകം എഴുതാൻ കഴിയുന്ന കോഡ് എഴുതുന്നതിനുള്ള ഒരു പുതിയതും സൗകര്യപ്രദവുമായ മാർഗ്ഗം ഇത് നൽകുന്നു. ഇത് പുതിയതും അടിസ്ഥാനപരമായി വേഗതയേറിയതുമായ ഒരു എക്സിക്യൂഷൻ മോഡൽ അവതരിപ്പിക്കുന്നില്ല.

നിങ്ങൾ ബേബൽ പോലുള്ള ഒരു ട്രാൻസ്പൈലർ ഉപയോഗിക്കുമ്പോൾ, നിങ്ങളുടെ പൈപ്പ്ലൈൻ കോഡ്:

            const result = input |> f |> g |> h;
            

              
                Copy
              
            
          

...എക്സിക്യൂട്ട് ചെയ്യുന്നതിന് മുമ്പ് ഇതുപോലൊന്നാക്കി മാറ്റുന്നു:

            const result = h(g(f(input)));
            

              
                Copy
              
            
          

അതുകൊണ്ട്, റൺടൈം പ്രകടനം നിങ്ങൾ നേരിട്ട് എഴുതുന്ന നെസ്റ്റഡ് ഫംഗ്ഷൻ കോളുകളുടേതിന് സമാനമാണ്. പൈപ്പ്ലൈൻ ഓപ്പറേറ്റർ നൽകുന്ന "ഒപ്റ്റിമൈസേഷൻ" മനുഷ്യർക്കാണ്, മെഷീനല്ല. ഇതിൻ്റെ പ്രയോജനങ്ങൾ ഇവയാണ്:

• കോഗ്നിറ്റീവ് ഒപ്റ്റിമൈസേഷൻ: പ്രവർത്തനങ്ങളുടെ ക്രമം മനസ്സിലാക്കാൻ കുറഞ്ഞ മാനസിക പരിശ്രമം മതി.
• മെയിൻ്റനബിലിറ്റി ഒപ്റ്റിമൈസേഷൻ: കോഡ് റീഫാക്ടർ ചെയ്യാനും, ഡീബഗ് ചെയ്യാനും, വികസിപ്പിക്കാനും എളുപ്പമാണ്. പൈപ്പ്ലൈനിലെ ഘട്ടങ്ങൾ ചേർക്കുന്നതും, നീക്കം ചെയ്യുന്നതും, പുനഃക്രമീകരിക്കുന്നതും നിസ്സാരമാണ്.
• റീഡബിലിറ്റി ഒപ്റ്റിമൈസേഷൻ: കോഡ് കൂടുതൽ ഡിക്ലറേറ്റീവ് ആകുന്നു, നിങ്ങൾ ഘട്ടം ഘട്ടമായി എങ്ങനെ നേടുന്നു എന്നതിനേക്കാൾ എന്ത് നേടാൻ ആഗ്രഹിക്കുന്നു എന്ന് ഇത് വ്യക്തമാക്കുന്നു.

ഇന്ന് പൈപ്പ്ലൈൻ ഓപ്പറേറ്റർ എങ്ങനെ ഉപയോഗിക്കാം

ഈ ഓപ്പറേറ്റർ ഇതുവരെ ഒരു സ്റ്റാൻഡേർഡ് അല്ലാത്തതിനാൽ, നിങ്ങളുടെ പ്രോജക്റ്റുകളിൽ ഇത് ഉപയോഗിക്കുന്നതിന് നിങ്ങൾ ഒരു ജാവാസ്ക്രിപ്റ്റ് ട്രാൻസ്പൈലർ ഉപയോഗിക്കണം. ഇതിനായി ഏറ്റവും സാധാരണയായി ഉപയോഗിക്കുന്ന ടൂൾ ബേബൽ ആണ്.

തുടങ്ങുന്നതിനുള്ള ഒരു അടിസ്ഥാന സെറ്റപ്പ് ഇതാ:

ഘട്ടം 1: ബേബൽ ഡിപെൻഡൻസികൾ ഇൻസ്റ്റാൾ ചെയ്യുക

നിങ്ങളുടെ പ്രോജക്റ്റ് ടെർമിനലിൽ, റൺ ചെയ്യുക:

            npm install --save-dev @babel/core @babel/cli @babel/plugin-proposal-pipeline-operator
            

              
                Copy
              
            
          

ഘട്ടം 2: ബേബൽ കോൺഫിഗർ ചെയ്യുക

നിങ്ങളുടെ പ്രോജക്റ്റിൻ്റെ റൂട്ട് ഡയറക്ടറിയിൽ ഒരു .babelrc.json ഫയൽ ഉണ്ടാക്കുക. ഇവിടെ, നിങ്ങൾ പൈപ്പ്ലൈൻ പ്ലഗിൻ കോൺഫിഗർ ചെയ്യും. ഏത് പ്രൊപ്പോസൽ ഉപയോഗിക്കണമെന്ന് നിങ്ങൾ തിരഞ്ഞെടുക്കണം.

# ടോക്കണുള്ള ഹാക്ക് പ്രൊപ്പോസലിനായി:

            {
  "plugins": [
    ["@babel/plugin-proposal-pipeline-operator", { "proposal": "hack", "topicToken": "#" }]
  ]
}
            

              
                Copy
              
            
          

മിനിമൽ പ്രൊപ്പോസലിനായി:

            {
  "plugins": [
    ["@babel/plugin-proposal-pipeline-operator", { "proposal": "minimal" }]
  ]
}
            

              
                Copy
              
            
          

ഘട്ടം 3: നിങ്ങളുടെ കോഡ് ട്രാൻസ്പൈൽ ചെയ്യുക

പൈപ്പ്ലൈൻ ഓപ്പറേറ്റർ അടങ്ങിയ നിങ്ങളുടെ സോഴ്സ് കോഡ് കംപൈൽ ചെയ്ത് എവിടെയും പ്രവർത്തിപ്പിക്കാൻ കഴിയുന്ന സ്റ്റാൻഡേർഡ് ജാവാസ്ക്രിപ്റ്റാക്കി മാറ്റാൻ നിങ്ങൾക്ക് ഇപ്പോൾ ബേബൽ ഉപയോഗിക്കാം.

നിങ്ങളുടെ package.json-ൽ ഒരു സ്ക്രിപ്റ്റ് ചേർക്കുക:

            "scripts": {
  "build": "babel src --out-dir dist"
}
            

              
                Copy
              
            
          

ഇപ്പോൾ, നിങ്ങൾ npm run build റൺ ചെയ്യുമ്പോൾ, ബേബൽ നിങ്ങളുടെ src ഡയറക്ടറിയിലെ കോഡ് എടുത്ത്, പൈപ്പ്ലൈൻ സിൻടാക്സ് മാറ്റി, ഫലം dist ഡയറക്ടറിയിലേക്ക് ഔട്ട്പുട്ട് ചെയ്യും.

ജാവാസ്ക്രിപ്റ്റിലെ ഫംഗ്ഷണൽ പ്രോഗ്രാമിംഗിൻ്റെ ഭാവി

ജാവാസ്ക്രിപ്റ്റിൽ കൂടുതൽ ഫംഗ്ഷണൽ പ്രോഗ്രാമിംഗ് ആശയങ്ങൾ ഉൾക്കൊള്ളുന്ന ഒരു വലിയ മുന്നേറ്റത്തിൻ്റെ ഭാഗമാണ് പൈപ്പ്ലൈൻ ഓപ്പറേറ്റർ. ആരോ ഫംഗ്ഷനുകൾ, ഓപ്ഷണൽ ചെയിനിംഗ് (`?.`), പാറ്റേൺ മാച്ചിംഗ്, പാർഷ്യൽ ആപ്ലിക്കേഷൻ പോലുള്ള മറ്റ് പ്രൊപ്പോസലുകൾ എന്നിവയുമായി സംയോജിപ്പിക്കുമ്പോൾ, കൂടുതൽ കരുത്തുറ്റതും ഡിക്ലറേറ്റീവും കോമ്പോസബിളുമായ കോഡ് എഴുതാൻ ഇത് ഡെവലപ്പർമാരെ പ്രാപ്തരാക്കുന്നു.

സോഫ്റ്റ്‌വെയർ ഡെവലപ്‌മെൻ്റിനെക്കുറിച്ച് ചെറിയ, പുനരുപയോഗിക്കാവുന്ന, പ്രവചിക്കാവുന്ന ഫംഗ്ഷനുകൾ ഉണ്ടാക്കുകയും പിന്നീട് അവയെ ശക്തവും മനോഹരവുമായ ഡാറ്റാ ഫ്ലോകളാക്കി മാറ്റുകയും ചെയ്യുന്ന ഒരു പ്രക്രിയയായി ചിന്തിക്കാൻ ഈ മാറ്റം നമ്മെ പ്രോത്സാഹിപ്പിക്കുന്നു. പൈപ്പ്ലൈൻ ഓപ്പറേറ്റർ ഈ രീതിയിലുള്ള പ്രോഗ്രാമിംഗിനെ ലോകമെമ്പാടുമുള്ള എല്ലാ ജാവാസ്ക്രിപ്റ്റ് ഡെവലപ്പർമാർക്കും കൂടുതൽ സ്വാഭാവികവും പ്രാപ്യവുമാക്കുന്ന ലളിതവും എന്നാൽ അഗാധവുമായ ഒരു ഉപകരണമാണ്.

ഉപസംഹാരം: വ്യക്തതയും കോമ്പോസിഷനും സ്വീകരിക്കാം

ജാവാസ്ക്രിപ്റ്റ് പൈപ്പ്ലൈൻ ഓപ്പറേറ്റർ (|>) ഭാഷയുടെ ഒരു സുപ്രധാന മുന്നേറ്റത്തെ പ്രതിനിധീകരിക്കുന്നു. ഫംഗ്ഷൻ കോമ്പോസിഷനായി ഒരു നേറ്റീവ്, വായിക്കാൻ എളുപ്പമുള്ള സിൻടാക്സ് നൽകുന്നതിലൂടെ, ആഴത്തിൽ നെസ്റ്റ് ചെയ്ത ഫംഗ്ഷൻ കോളുകളുടെ ദീർഘകാലമായുള്ള പ്രശ്നം ഇത് പരിഹരിക്കുകയും ബാഹ്യ യൂട്ടിലിറ്റി ലൈബ്രറികളുടെ ആവശ്യം കുറയ്ക്കുകയും ചെയ്യുന്നു.

പ്രധാന കാര്യങ്ങൾ:

• വായനാക്ഷമത മെച്ചപ്പെടുത്തുന്നു: ഇത് പിന്തുടരാൻ എളുപ്പമുള്ള രേഖീയവും ഇടത്തുനിന്ന് വലത്തോട്ടുള്ളതുമായ ഒരു ഡാറ്റാ ഫ്ലോ സൃഷ്ടിക്കുന്നു.
• പരിപാലനം മെച്ചപ്പെടുത്തുന്നു: പൈപ്പ്ലൈനുകൾ ഡീബഗ് ചെയ്യാനും പരിഷ്കരിക്കാനും ലളിതമാണ്.
• ഫംഗ്ഷണൽ ശൈലി പ്രോത്സാഹിപ്പിക്കുന്നു: സങ്കീർണ്ണമായ പ്രശ്നങ്ങളെ ചെറിയ, കോമ്പോസ് ചെയ്യാവുന്ന ഫംഗ്ഷനുകളായി വിഭജിക്കാൻ ഇത് പ്രോത്സാഹിപ്പിക്കുന്നു.
• ഇതൊരു പ്രൊപ്പോസലാണ്: ഇതിൻ്റെ സ്റ്റേജ് 2 സ്റ്റാറ്റസ് ഓർക്കുക, പ്രൊഡക്ഷൻ പ്രോജക്റ്റുകൾക്കായി ബേബൽ പോലുള്ള ഒരു ട്രാൻസ്പൈലർ ഉപയോഗിച്ച് ഇത് ഉപയോഗിക്കുക.

അന്തിമ സിൻടാക്സ് ഇപ്പോഴും ചർച്ചയിലാണെങ്കിലും, ഓപ്പറേറ്ററിൻ്റെ പ്രധാന മൂല്യം വ്യക്തമാണ്. ഇന്ന് ഇത് പരിചയപ്പെടുന്നതിലൂടെ, നിങ്ങൾ ഒരു പുതിയ സിൻടാക്സ് പഠിക്കുക മാത്രമല്ല ചെയ്യുന്നത്; നിങ്ങൾ ജാവാസ്ക്രിപ്റ്റ് എഴുതുന്നതിനുള്ള വൃത്തിയുള്ളതും കൂടുതൽ ഡിക്ലറേറ്റീവും ആത്യന്തികമായി കൂടുതൽ ശക്തവുമായ ഒരു മാർഗ്ഗത്തിൽ നിക്ഷേപിക്കുകയാണ്.